(function () {
  var MutationObserver,
    Util,
    WeakMap,
    getComputedStyle,
    getComputedStyleRX,
    bind = function (fn, me) {
      return function () {
        return fn.apply(me, arguments);
      };
    },
    indexOf =
      [].indexOf ||
      function (item) {
        for (var i = 0, l = this.length; i < l; i++) {
          if (i in this && this[i] === item) return i;
        }
        return -1;
      };

  Util = (function () {
    function Util() {}

    Util.prototype.extend = function (custom, defaults) {
      var key, value;
      for (key in defaults) {
        value = defaults[key];
        if (custom[key] == null) {
          custom[key] = value;
        }
      }
      return custom;
    };

    Util.prototype.isMobile = function (agent) {
      return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
        agent
      );
    };

    Util.prototype.createEvent = function (event, bubble, cancel, detail) {
      var customEvent;
      if (bubble == null) {
        bubble = false;
      }
      if (cancel == null) {
        cancel = false;
      }
      if (detail == null) {
        detail = null;
      }
      if (document.createEvent != null) {
        customEvent = document.createEvent("CustomEvent");
        customEvent.initCustomEvent(event, bubble, cancel, detail);
      } else if (document.createEventObject != null) {
        customEvent = document.createEventObject();
        customEvent.eventType = event;
      } else {
        customEvent.eventName = event;
      }
      return customEvent;
    };

    Util.prototype.emitEvent = function (elem, event) {
      if (elem.dispatchEvent != null) {
        return elem.dispatchEvent(event);
      } else if (event in (elem != null)) {
        return elem[event]();
      } else if ("on" + event in (elem != null)) {
        return elem["on" + event]();
      }
    };

    Util.prototype.addEvent = function (elem, event, fn) {
      if (elem.addEventListener != null) {
        return elem.addEventListener(event, fn, false);
      } else if (elem.attachEvent != null) {
        return elem.attachEvent("on" + event, fn);
      } else {
        return (elem[event] = fn);
      }
    };

    Util.prototype.removeEvent = function (elem, event, fn) {
      if (elem.removeEventListener != null) {
        return elem.removeEventListener(event, fn, false);
      } else if (elem.detachEvent != null) {
        return elem.detachEvent("on" + event, fn);
      } else {
        return delete elem[event];
      }
    };

    Util.prototype.innerHeight = function () {
      if ("innerHeight" in window) {
        return window.innerHeight;
      } else {
        return document.documentElement.clientHeight;
      }
    };

    return Util;
  })();

  WeakMap =
    this.WeakMap ||
    this.MozWeakMap ||
    (WeakMap = (function () {
      function WeakMap() {
        this.keys = [];
        this.values = [];
      }

      WeakMap.prototype.get = function (key) {
        var i, item, j, len, ref;
        ref = this.keys;
        for (i = j = 0, len = ref.length; j < len; i = ++j) {
          item = ref[i];
          if (item === key) {
            return this.values[i];
          }
        }
      };

      WeakMap.prototype.set = function (key, value) {
        var i, item, j, len, ref;
        ref = this.keys;
        for (i = j = 0, len = ref.length; j < len; i = ++j) {
          item = ref[i];
          if (item === key) {
            this.values[i] = value;
            return;
          }
        }
        this.keys.push(key);
        return this.values.push(value);
      };

      return WeakMap;
    })());

  MutationObserver =
    this.MutationObserver ||
    this.WebkitMutationObserver ||
    this.MozMutationObserver ||
    (MutationObserver = (function () {
      function MutationObserver() {
        if (typeof console !== "undefined" && console !== null) {
          console.warn("MutationObserver is not supported by your browser.");
        }
        if (typeof console !== "undefined" && console !== null) {
          console.warn(
            "WOW.js cannot detect dom mutations, please call .sync() after loading new content."
          );
        }
      }

      MutationObserver.notSupported = true;

      MutationObserver.prototype.observe = function () {};

      return MutationObserver;
    })());

  getComputedStyle =
    this.getComputedStyle ||
    function (el, pseudo) {
      this.getPropertyValue = function (prop) {
        var ref;
        if (prop === "float") {
          prop = "styleFloat";
        }
        if (getComputedStyleRX.test(prop)) {
          prop.replace(getComputedStyleRX, function (_, _char) {
            return _char.toUpperCase();
          });
        }
        return ((ref = el.currentStyle) != null ? ref[prop] : void 0) || null;
      };
      return this;
    };

  getComputedStyleRX = /(\-([a-z]){1})/g;

  this.WOW = (function () {
    WOW.prototype.defaults = {
      boxClass: "wow",
      animateClass: "animated",
      offset: 0,
      mobile: true,
      live: true,
      callback: null,
    };

    function WOW(options) {
      if (options == null) {
        options = {};
      }
      this.scrollCallback = bind(this.scrollCallback, this);
      this.scrollHandler = bind(this.scrollHandler, this);
      this.resetAnimation = bind(this.resetAnimation, this);
      this.start = bind(this.start, this);
      this.scrolled = true;
      this.config = this.util().extend(options, this.defaults);
      this.animationNameCache = new WeakMap();
      this.wowEvent = this.util().createEvent(this.config.boxClass);
    }

    WOW.prototype.init = function () {
      var ref;
      this.element = window.document.documentElement;
      if ((ref = document.readyState) === "interactive" || ref === "complete") {
        this.start();
      } else {
        this.util().addEvent(document, "DOMContentLoaded", this.start);
      }
      return (this.finished = []);
    };

    WOW.prototype.start = function () {
      var box, j, len, ref;
      this.stopped = false;
      this.boxes = function () {
        var j, len, ref, results;
        ref = this.element.querySelectorAll("." + this.config.boxClass);
        results = [];
        for (j = 0, len = ref.length; j < len; j++) {
          box = ref[j];
          results.push(box);
        }
        return results;
      }.call(this);
      this.all = function () {
        var j, len, ref, results;
        ref = this.boxes;
        results = [];
        for (j = 0, len = ref.length; j < len; j++) {
          box = ref[j];
          results.push(box);
        }
        return results;
      }.call(this);
      if (this.boxes.length) {
        if (this.disabled()) {
          this.resetStyle();
        } else {
          ref = this.boxes;
          for (j = 0, len = ref.length; j < len; j++) {
            box = ref[j];
            this.applyStyle(box, true);
          }
        }
      }
      if (!this.disabled()) {
        this.util().addEvent(window, "scroll", this.scrollHandler);
        this.util().addEvent(window, "resize", this.scrollHandler);
        this.interval = setInterval(this.scrollCallback, 50);
      }
      if (this.config.live) {
        return new MutationObserver(
          (function (_this) {
            return function (records) {
              var k, len1, node, record, results;
              results = [];
              for (k = 0, len1 = records.length; k < len1; k++) {
                record = records[k];
                results.push(
                  function () {
                    var l, len2, ref1, results1;
                    ref1 = record.addedNodes || [];
                    results1 = [];
                    for (l = 0, len2 = ref1.length; l < len2; l++) {
                      node = ref1[l];
                      results1.push(this.doSync(node));
                    }
                    return results1;
                  }.call(_this)
                );
              }
              return results;
            };
          })(this)
        ).observe(document.body, {
          childList: true,
          subtree: true,
        });
      }
    };

    WOW.prototype.stop = function () {
      this.stopped = true;
      this.util().removeEvent(window, "scroll", this.scrollHandler);
      this.util().removeEvent(window, "resize", this.scrollHandler);
      if (this.interval != null) {
        return clearInterval(this.interval);
      }
    };

    WOW.prototype.sync = function (element) {
      if (MutationObserver.notSupported) {
        return this.doSync(this.element);
      }
    };

    WOW.prototype.doSync = function (element) {
      var box, j, len, ref, results;
      if (element == null) {
        element = this.element;
      }
      if (element.nodeType !== 1) {
        return;
      }
      element = element.parentNode || element;
      ref = element.querySelectorAll("." + this.config.boxClass);
      results = [];
      for (j = 0, len = ref.length; j < len; j++) {
        box = ref[j];
        if (indexOf.call(this.all, box) < 0) {
          this.boxes.push(box);
          this.all.push(box);
          if (this.stopped || this.disabled()) {
            this.resetStyle();
          } else {
            this.applyStyle(box, true);
          }
          results.push((this.scrolled = true));
        } else {
          results.push(void 0);
        }
      }
      return results;
    };

    WOW.prototype.show = function (box) {
      this.applyStyle(box);
      box.className = box.className + " " + this.config.animateClass;
      if (this.config.callback != null) {
        this.config.callback(box);
      }
      this.util().emitEvent(box, this.wowEvent);
      this.util().addEvent(box, "animationend", this.resetAnimation);
      this.util().addEvent(box, "oanimationend", this.resetAnimation);
      this.util().addEvent(box, "webkitAnimationEnd", this.resetAnimation);
      this.util().addEvent(box, "MSAnimationEnd", this.resetAnimation);
      return box;
    };

    WOW.prototype.applyStyle = function (box, hidden) {
      var delay, duration, iteration;
      duration = box.getAttribute("data-wow-duration");
      delay = box.getAttribute("data-wow-delay");
      iteration = box.getAttribute("data-wow-iteration");
      return this.animate(
        (function (_this) {
          return function () {
            return _this.customStyle(box, hidden, duration, delay, iteration);
          };
        })(this)
      );
    };

    WOW.prototype.animate = (function () {
      if ("requestAnimationFrame" in window) {
        return function (callback) {
          return window.requestAnimationFrame(callback);
        };
      } else {
        return function (callback) {
          return callback();
        };
      }
    })();

    WOW.prototype.resetStyle = function () {
      var box, j, len, ref, results;
      ref = this.boxes;
      results = [];
      for (j = 0, len = ref.length; j < len; j++) {
        box = ref[j];
        results.push((box.style.visibility = "visible"));
      }
      return results;
    };

    WOW.prototype.resetAnimation = function (event) {
      var target;
      if (event.type.toLowerCase().indexOf("animationend") >= 0) {
        target = event.target || event.srcElement;
        return (target.className = target.className
          .replace(this.config.animateClass, "")
          .trim());
      }
    };

    WOW.prototype.customStyle = function (
      box,
      hidden,
      duration,
      delay,
      iteration
    ) {
      if (hidden) {
        this.cacheAnimationName(box);
      }
      box.style.visibility = hidden ? "hidden" : "visible";
      if (duration) {
        this.vendorSet(box.style, {
          animationDuration: duration,
        });
      }
      if (delay) {
        this.vendorSet(box.style, {
          animationDelay: delay,
        });
      }
      if (iteration) {
        this.vendorSet(box.style, {
          animationIterationCount: iteration,
        });
      }
      this.vendorSet(box.style, {
        animationName: hidden ? "none" : this.cachedAnimationName(box),
      });
      return box;
    };

    WOW.prototype.vendors = ["moz", "webkit"];

    WOW.prototype.vendorSet = function (elem, properties) {
      var name, results, value, vendor;
      results = [];
      for (name in properties) {
        value = properties[name];
        elem["" + name] = value;
        results.push(
          function () {
            var j, len, ref, results1;
            ref = this.vendors;
            results1 = [];
            for (j = 0, len = ref.length; j < len; j++) {
              vendor = ref[j];
              results1.push(
                (elem[
                  "" + vendor + name.charAt(0).toUpperCase() + name.substr(1)
                ] = value)
              );
            }
            return results1;
          }.call(this)
        );
      }
      return results;
    };

    WOW.prototype.vendorCSS = function (elem, property) {
      var j, len, ref, result, style, vendor;
      style = getComputedStyle(elem);
      result = style.getPropertyCSSValue(property);
      ref = this.vendors;
      for (j = 0, len = ref.length; j < len; j++) {
        vendor = ref[j];
        result =
          result || style.getPropertyCSSValue("-" + vendor + "-" + property);
      }
      return result;
    };

    WOW.prototype.animationName = function (box) {
      var animationName;
      try {
        animationName = this.vendorCSS(box, "animation-name").cssText;
      } catch (_error) {
        animationName =
          getComputedStyle(box).getPropertyValue("animation-name");
      }
      if (animationName === "none") {
        return "";
      } else {
        return animationName;
      }
    };

    WOW.prototype.cacheAnimationName = function (box) {
      return this.animationNameCache.set(box, this.animationName(box));
    };

    WOW.prototype.cachedAnimationName = function (box) {
      return this.animationNameCache.get(box);
    };

    WOW.prototype.scrollHandler = function () {
      return (this.scrolled = true);
    };

    WOW.prototype.scrollCallback = function () {
      var box;
      if (this.scrolled) {
        this.scrolled = false;
        this.boxes = function () {
          var j, len, ref, results;
          ref = this.boxes;
          results = [];
          for (j = 0, len = ref.length; j < len; j++) {
            box = ref[j];
            if (!box) {
              continue;
            }
            if (this.isVisible(box)) {
              this.show(box);
              continue;
            }
            results.push(box);
          }
          return results;
        }.call(this);
        if (!(this.boxes.length || this.config.live)) {
          return this.stop();
        }
      }
    };

    WOW.prototype.offsetTop = function (element) {
      var top;
      while (element.offsetTop === void 0) {
        element = element.parentNode;
      }
      top = element.offsetTop;
      while ((element = element.offsetParent)) {
        top += element.offsetTop;
      }
      return top;
    };

    WOW.prototype.isVisible = function (box) {
      var bottom, offset, top, viewBottom, viewTop;
      offset = box.getAttribute("data-wow-offset") || this.config.offset;
      viewTop = window.pageYOffset;
      viewBottom =
        viewTop +
        Math.min(this.element.clientHeight, this.util().innerHeight()) -
        offset;
      top = this.offsetTop(box);
      bottom = top + box.clientHeight;
      return top <= viewBottom && bottom >= viewTop;
    };

    WOW.prototype.util = function () {
      return this._util != null ? this._util : (this._util = new Util());
    };

    WOW.prototype.disabled = function () {
      return !this.config.mobile && this.util().isMobile(navigator.userAgent);
    };

    return WOW;
  })();
}.call(this));
